import numpy as np  
from scipy.ndimage import convolve  

def cov(p, t, w, h, kernel_w, kernel_h, step_w, step_h):  
    # 确保输入是NumPy数组  
    p = np.asarray(p, dtype=np.uint8)  
    t = np.asarray(t, dtype=np.uint8)  
    # 检查输入数组的形状  
    assert p.shape == (h, w), "Array p should be of shape (h, w)"  
    assert t.shape == (kernel_h, kernel_w), "Array t should be of shape (kernel_h, kernel_w)"  
    
    # 初始化输出数组  
    output = np.zeros((h // step_h, w // step_w), dtype=np.uint8)  
    
    # 计算卷积  
    for i in range(0, h - kernel_h + 1, step_h):  
        for j in range(0, w - kernel_w + 1, step_w):  
            # 提取p和t的子数组  
            p_sub = p[i:i+kernel_h, j:j+kernel_w]  
            t_sub = t  
            
            # 计算点积并加到输出数组中  
            output[i//step_h, j//step_w] = np.sum(p_sub * t_sub)  
    
    # 返回输出数组（如果需要，可以转换为uint8数组）  
    return output.astype(np.uint8)  
# 假设 p 和 t 是二维数组（列表的列表或者NumPy数组）  
# w 和 h 是 p 的宽度和高度  
# kernel_w 和 kernel_h 是 t 的宽度和高度  
# step_w 和 step_h 是卷积的步长  
# 使用函数  
# output = cov(p, t, w, h, kernel_w, kernel_h, step_w, step_h)





def dot_multiply(p, t, w, h):  
    # 确保输入是NumPy数组  
    p = np.asarray(p, dtype=np.uint8)  
    t = np.asarray(t, dtype=np.uint8)  
    # 检查输入数组的形状  
    assert p.shape == (h, w), "Array p should be of shape (h, w)"  
    assert t.shape == (h, w), "Array t should be of shape (h, w)"  
    # 计算逐点乘法  
    q = p * t  
    # 无需类型转换，因为p和t已经是uint8，逐点乘法的结果也将是uint8  
    # 但如果需要考虑溢出问题，则可能需要进行额外处理      
    # 返回结果数组  
    return q  
# 假设 p 和 t 是二维数组（列表的列表或者NumPy数组）  
# w 和 h 是 p 和 t 的宽度和高度  
# 使用函数  
# q = dot_multiply(p, t, w, h)






def gaussian_kernel(size, sigma):  
    """Create a Gaussian kernel."""  
    x, y = np.mgrid[-size//2 + 1:size//2 + 1, -size//2 + 1:size//2 + 1]  
    g = np.exp(-(x**2 + y**2) / (2.*sigma**2))  
    return g / g.sum()  
def gaussian_filter(image, kernel):  
    """Apply a Gaussian filter to an image."""  
    return convolve(image, kernel, mode='constant', cval=0.0)  
# 假设 image 是一个二维的NumPy数组（即图像）  
# size 是高斯核的大小（必须是奇数）  
# sigma 是高斯函数的标准差  
'''
kernel = gaussian_kernel(size=3, sigma=1.0)  # 创建一个3x3的高斯核  
filtered_image = gaussian_filter(image, kernel)  # 应用高斯滤波
'''





def laplacian_kernel():  
    """返回3x3的拉普拉斯核"""  
    kernel = np.array([[0, 1, 0],  
                        [1, -4, 1],  
                        [0, 1, 0]], dtype=np.float32)  
    return kernel  

def laplacian(image, kernel):  
    """对图像应用拉普拉斯算子"""  
    # 使用scipy的convolve函数进行卷积  
    convolved = convolve(image, kernel)  
    # 计算绝对值  
    output = np.abs(convolved)  
    # 如果需要，可以将输出转换为uint8类型  
    output = np.uint8(output)  
    return output  
# 假设image是输入的灰度图像，其数据类型为np.uint8  
# image = ... # 这里应该是加载或创建图像的代码  
# 定义图像的宽度和高度（这些值需要根据实际情况来设定）  
'''
# 创建拉普拉斯核  
kernel = laplacian_kernel()  
# 应用拉普拉斯算子到图像上  
output = laplacian(image, kernel)  
# 输出处理后的图像  
'''
